# -*- coding: utf-8 -*-
import math
import random
import time
import traceback
from mod.common.minecraftEnum import EntityType
from mod.server import extraServerApi
from mod.server.extraServerApi import GetMinecraftEnum
from legendaryPowerScript.battle.element import Element
from legendaryPowerScript.item import itemTypes
from mod_log import logger
import legendaryPowerScript._lpcommon.vector as vector
from legendaryPowerScript._lpcommon.vector import Vector
from legendaryPowerScript.item.legendaryItem import LegendaryItem
from legendaryPowerScript._lpcommon import boundingboxes, apiUtil
from legendaryPowerScript._lpcommon.boundingboxes import CuboidBoundingBox, SphereBoundingBox
from .battle.handler import Handler
from .playerStorage import PlayerStorage
from .item.inventory import Inventory
from legendaryPowerScript.shop.shopGoods import ShopGood
from legendaryPowerScript.mob.mobtype import ActiveMob
from petScript.pet.activePet import ActivePet
from .scheduler import Task
from .statTypes import triggerTypes
def firstId():
    # type: () -> str
    """
    获取第一个玩家的实体ID。

    Returns:
        str: 第一个玩家的实体ID。若没有玩家，则返回"-1"。
    """
    return ""


class StatType:
    def __init__(self, name, config):
        # type: (str, dict) -> None
        """
        实体的属性类型，在item/config.yml中可以自定义。
        Attributes:
            name (str): 属性类型的名称。
            displayName (str): 属性类型的显示名称。
            precision (int): 统计值的精度，用于控制小数位数。
            powerMultiplier (int): 属性类型的战力乘数。
            powerMultiplyStat (str or None): 战力乘数的属性类型名称。
            isPercent (bool): 属性类型是否为百分比。
            baseValue (float): 属性类型的基础值。
            applyType (int): 属性类型的应用类型。
            display (bool): 属性类型是否在物品描述中显示。
            growth (int or None): 每级成长值。
            affectedByEnhance (bool): 属性类型是否受强化品质影响。
            cannotEquip (bool): 属性类型是否不可装备。
        """
        pass

class Stat:
    def __init__(self, type, amount):
        # type: (StatType or str, float) -> None
        """
        实体的属性。
    
        Attributes:
            type (StatType): 属性类型对象。
            amount (float): 属性数值。
        """
        pass

    def toLore(self):
        # type: () -> str
        """
        将属性转换为用于描述的字符串。

        Returns:
            str: 描述的字符串表示。
        """
        return ""


class ShieldAmount:
    def __init__(self, key, amount, duration):
        # type: () -> None
        """
        表示护盾数值的类。不同来源的护盾由key定义。

        Attributes:
            key (str): 护盾的关键字。同一来源的护盾会覆盖已有的，不同来源的护盾会叠加。
            amount (float): 护盾的数值。
            duration (float): 护盾的持续时间。
        """
        self.key  = ""
        self.amount  = 0.0
        self.duration  = 0.0

class Fighter:
    def __init__(self, entityId, entityType, boundingBox=None, scale=1.0):
        # type: () -> None
        """
        表示实体的类、游戏中的所有实体都可以被这个类代表
        Attributes:
            entityId: str  # 实体的实体ID
            boundingBox: List[float, float] # 实体的包围盒大小，两个元素：横向直径 纵向直径
            scale: float  # 实体的缩放比例，默认为1.0
            isPlayer: bool  # 标识实体是否为玩家
            modifyiedSpells: List[Spell]  # 克隆后的魔法（魔法可以克隆并更改参数，克隆后的存在这里，并用GetSpell获取）
            gamemode: int  # 游戏模式，0=生存 1=创造 2=冒险
            inited: bool  # 若是玩家：是否已初始化。在完成载入存档数据后变为True
            blockMessages: bool  # 是否屏蔽消息。若打开，则被拦截的消息会存到lastMessage中
            lastMessage: str  # 上一条被拦截的消息
            playerStorage: PlayerStorage  # 若是玩家：与玩家相关的存档数据。若不是玩家则为None
            lastDamagerId: str  # 上次受伤的攻击者实体ID
            vanillaDamageTime: long  # 上次受到原版伤害的time.time()时间
            guildOwner: str  # 所属的公会名。玩家处于公会中，或是使用召唤魔法召唤出的实体会有此属性，否则为None
            riding: Fighter  # 骑乘对象实体
            lastAttackTime: int  # 上次攻击时间（以开服后经过的tick算，可与apiUtil.timeStamp比对）
            _shield: dict[str, ShieldAmount]  # 当前拥有的护盾
            _health: float  # 当前生命值缓存
            isNpc: bool  # 是否为NPC
            isFlying: bool  # 是否正在飞行
            inBattleCountdown: int  # 脱离战斗的时间点（以开服后经过的tick算，可与apiUtil.timeStamp比对）
            _maxHealth: float  # 最大生命值缓存
            _mana: float  # 当前法力值缓存
            _maxMana: float  # 最大法力值缓存
            _entityDead: bool  # 实体是否死亡
            deleted: bool  # 实体是否已被删除
            status: type: dict[str, dict[str, Stat]]  # 实体的属性。建议直接用getStat()或者getStatAmount()。
                                                        第一层字典的key是属性的来源，第二层的key是属性名（item/config.yml中配置）
            bb: Any  # 实体包围盒
            _name: str  # 名称缓存
            invincible: bool  # 是否无敌
            channelingSkill: Any  # 正在引导的技能序号（技能的装备位置）
            targetedHealth: set[Fighter]  # 正在向哪些玩家展示它的血条
            targetingHealth: Fighter  # 正在看谁的血条
            peacefulCooldown: int  # 和平模式冷却时间
            canBeTargeted: bool  # 是否可以被魔法指定为目标
            sendExceptions: bool  # 是否接收异常信息
            sendNotify: bool  # 是否接收通知信息
            coolingDownSpells: dict[str, int]  # 冷却中的技能名和完成冷却的时间戳（time.time()）
            owner: Fighter or None  # 所有者
            ownerCastInstead: bool  # 释放魔法时，是否改为让所有者施放
            tryingEquipment: ShopGood or None  # 正在试用的商品
            activeMob: ActiveMob  # 若该实体是怪物：对应怪物的实例
            activePet: ActivePet  # 若该实体是宠物：对应宠物精灵的实例
            activeBuff: dict[str, ActiveBuff]  # 当前激活的增益效果
            variables: # type: dict[str, float]  # 拥有的变量
            attackSpeed: float  # 攻击速度缓存
            attackRange: float  # 攻击范围缓存
            permaOwnedSkills: List[str]  # 永久拥有的技能列表，玩家下线后会保存。在释放魔法时，若魔法设置了“需要拥有:true”，则必须魔法名在这里面才能释放
            tempOwnedSkills: List[str]  # 临时拥有的技能列表，在释放魔法时，若魔法设置了“需要拥有:true”，则必须魔法名在这里面才能释放
            inventory: Inventory  # 玩家的背包
            swapingWorld: bool  # 玩家是否正在切换世界
            finishingQuest: List[Quest]  # 正在完成的任务列表
            avoidBattle: bool  # 是否玩家处于暂停状态。在看剧情，交易等情况下会进入此状态。此状态下不会受到伤害，但玩家也无法攻击、移动
            prevAvoidBattlePos: Any  # 上次进入暂停状态的位置
            titles: dict[str, dict]  # 称号列表
            passiveSpells: List[Any]  # 被动技能列表
            handledDeath: bool  # 是否已处理过死亡事件
            equippedHead: bool  # 是否装备了头部物品
            equippedChest: bool  # 是否装备了胸部物品
            equippedLeg: bool  # 是否装备了腿部物品
            equippedFeet: bool  # 是否装备了脚部物品
            equippedWing: bool  # 是否装备了翅膀
            swimming: bool  # 是否正在游泳
            attackCd: int  # 普通攻击冷却完成的时间戳（time.time()）
            canTeleport: bool  # 是否可以传送
            killer: Fighter or None  # 杀死自己的实体
            handlers: type: dict[str, Handler]  # 当前的所有词条处理器。添加词条请用addHandler，移除词条请用removeHandler
            attackSound: str  # 攻击音效
            critSound: str  # 暴击音效
            hurtSound: str  # 受伤音效
            dieSound: str  # 死亡音效
            tempEquipment: dict[int, LegendaryItem]  # 临时装备池。获取装备时，若装备在这里存在，则加载这里的装备。否则尝试从inventory中加载
            tempEquipmentDuration: int  # 临时装备倒计时时间。从1变成0时会清空tempEquipment
            attackSfx: bool  # 是否播放攻击特效
            suffix: str  # 聊天后缀文本
            prefix: str  # 聊天前缀文本
            power: float  # 战斗力缓存。建议用getPower()
            moving: bool  # 是否正在移动
            sprinting: bool  # 是否正在奔跑
            silenced: dict[str, list[str]]  # 被沉默的魔法名关键词。key是来源，value是关键词
            lastChatTime: long  # 上次聊天时间戳（time.time()）
            timeupCallback: callable  # 当前的倒计时的时间到回调函数
            boundModel: dict  # 绑定到该实体上的模型
            bindTo: Fighter or None  # 绑定到的实体
            lastStat: dict[str, float]  # 上次刷新时的属性，key为属性名，value为属性总值
            spellIndex: dict[str, int]  # 装备中的技能的序号，key为技能名，value为装备的序号
            tweens: list[Tween]  # 正在运行的补间动画
            dotAmount: float  # Dot伤害总量缓存
            shieldAmount: float  # 护盾总量缓存
            banGlideZone: bool  # 正处于禁止滑翔的区域中
            banTeleportZone: bool  # 正处于禁止传送的区域中
            digging: dict  # 玩家是否正在打开需要引导的野外宝箱，默认None（未挖掘状态） 指令/lp resetdigging 可解除 {
                "crateEntity": crateEntity,
                "bound": bound,
                "triggerTimes": triggerTimes,
                "entityId": crateEntityId
            }
        """
        self.entityId = ""
        self.boundingBox = []
        self.scale = 0.0
        self.isPlayer = False
        self.modifyiedSpells = []
        self.gamemode = 0
        self.inited = False
        self.blockMessages = False
        self.lastMessage = ""
        self.playerStorage = PlayerStorage()
        self.lastDamagerId = ""
        self.vanillaDamageTime = 0
        self.guildOwner = ""
        self.riding = Fighter()
        self.lastAttackTime = 0
        self._shield = ""
        self._health = 0.0
        self.isNpc = False
        self.isFlying = False
        self.inBattleCountdown = 0
        self._maxHealth = 0.0
        self._mana = 0.0
        self._maxMana = 0.0
        self._entityDead = False
        self.deleted = False
        self.status = ""
        self.bb = Any()
        self._name = ""
        self.invincible = False
        self.channelingSkill = Any()
        self.targetedHealth = set()
        self.targetingHealth = Fighter()
        self.peacefulCooldown = 0
        self.canBeTargeted = False
        self.sendExceptions = False
        self.sendNotify = False
        self.coolingDownSpells = ""
        self.owner = Fighter()
        self.ownerCastInstead = False
        self.tryingEquipment = ShopGood()
        self.activeMob = ActiveMob()
        self.activePet = ActivePet()
        self.activeBuff = ""
        self.attackSpeed = 0.0
        self.attackRange = 0.0
        self.permaOwnedSkills = ""
        self.tempOwnedSkills = ""
        self.inventory = Inventory()
        self.swapingWorld = False
        self.finishingQuest = []
        self.avoidBattle = False
        self.prevAvoidBattlePos = Any()
        self.titles = ""
        self.passiveSpells = []
        self.handledDeath = False
        self.equippedHead = False
        self.equippedChest = False
        self.equippedLeg = False
        self.equippedFeet = False
        self.equippedWing = False
        self.swimming = False
        self.attackCd = 0
        self.canTeleport = False
        self.killer = Fighter()
        self.handlers = ""
        self.attackSound = ""
        self.critSound = ""
        self.hurtSound = ""
        self.dieSound = ""
        self.tempEquipment = {}
        self.tempEquipmentDuration = 0
        self.attackSfx = False
        self.suffix = ""
        self.prefix = ""
        self.power = 0.0
        self.moving = False
        self.sprinting = False
        self.silenced = ""
        self.lastChatTime = 0
        self.timeupCallback = None # callable
        self.boundModel = {}
        self.bindTo = Fighter()
        self.lastStat = ""
        self.spellIndex = ""
        self.tweens = []
        self.dotAmount = 0.0
        self.shieldAmount = 0.0
        self.banGlideZone = False
        self.banTeleportZone = False
        self.digging = {}

    def setTimeLimit(self, timeLeft, timeupCallback):
        # type: (int, callable) -> None
        """
        设置时间限制。

        参数：
            - timeLeft (int)：剩余时间，以秒为单位。
            - timeupCallback (callable)：时间到时的回调函数。

        注意：
            - 如果已经存在时间限制任务，则会取消之前的任务。
            - 如果当前处于飞行状态，将自动关闭飞行。
        """
        pass

    def getWorldKey(self):
        # type: () -> - tuple[int, int]
        """
        获取世界键值。在主世界中，每3000x3000划分为一个“世界”。这是为了避免玩家在切换维度时加载黑屏。当-4500<xz<4500时代表玩家在主世界，返回None。否则返回(x//3000,z//3000)
        返回：
            - tuple[int, int]: 世界键值。
        """
        return ()


    def addKarma(self, change):
        # type: (float) -> None
        """
        增加或减少人品值。
        参数：
            - change (float)：变化的人品值。
        """
        pass

    def refreshPower(self):
        # type: () -> None
        """
        刷新战力值。战力值会保存在self.power属性中
        """
        pass

    def _calculateDictPower(self, status, power):
        # type: (dict[str, Stat], float) -> - float
        """
        计算字典中的战力值。

        参数：
            - status (dict[str, Stat])：包含属性和数值的字典。
            - power (float)：当前的战力值。

        返回：
            - float: 计算后的新战力值。
        """
        return 0.0


    def canSee(self, target, angle, angleOffset=.0, lookDirection=None):
        # type: (Fighter, float, float, Vector) -> None
        """
        判断是否能够看到目标。

        参数：
            - target (Fighter)：要判断是否可见的目标。
            - angle (float)：视野的角度，以度为单位。
            - angleOffset (float)：视角偏移的角度，以度为单位，默认为0。
            - lookDirection (Vector)：朝向的方向，默认为当前对象的朝向。

        返回：
            - bool：是否可见。
        """
        pass

    def setCanTeleport(self, canTeleport):
        # type: (bool) -> None
        """
        设置是否可以传送。

        参数：
            - canTeleport (bool)：是否可以传送。
        """
        pass

    def queryLeaveDungeon(self):
        # type: () -> None
        """
        询问是否离开地牢

        Returns:
            None
        """
        pass

    def addHandler(self, handler):
        # type: (Handler) -> None
        """
        添加词条处理器

        Args:
            handler (Handler): 事件处理器对象
        Returns:
            None
        """
        pass

    def setModel(self, model):
        # type: (str) -> None
        """
        临时设置骨骼模型。不会保存

        参数：
            - model (str)：模型在netease_models.json中注册的名称
        """
        pass

    def triggerPassiveSpells(self, target, data, key):
        # type: (Fighter, dict[str, Any], str) -> None
        """
        触发被动技能。

        参数：
            - target (Fighter)：目标对象
            - data (dict[str, Any])：事件相关数据
            - key (str)：触发事件名

        返回：
            无返回值
        """
        pass

    def AppendTitle(self, category, text):
        # type: (str, str) -> None
        """
        添加称号。

        参数：
            - category (str)：称号分类
            - data (str)：称号内容

        返回：
            无返回值
        """
        pass

    def GetSpell(self, name):
        # type: (str) -> Spell or None
        """
        获取魔法。若有克隆的修改过的魔法，则返回克隆的。否则从spellManager中返回默认的魔法。

        参数：
            - name (str)：魔法名称

        返回：
            - spell (Spell or None)：魔法
        """
        return Spell()


    def getBattleName(self):
        # type: () -> str
        """
        获取用于在战斗中显示的名称。
        参数：
            无参数

        返回：
            - battleName (str)：战斗名称
        """
        return ""


    def getName(self):
        # type: () -> str
        """
        获取名称。

        参数：
            无参数
        返回：
            - name (str)：名称
        """
        return ""


    def setAnimationSpeed(self, entityId, animation, multiplier):
        # type: (int, str, float) -> None
        """
        设置动画速度。

        参数：
            - entityId (int)：实体的唯一标识符。
            - animation (str)：要播放的动画的名称。
            - multiplier (float)：动画的速度倍数。

        返回：
            无返回值。
        """
        pass

    def setMolangVariable(self, name, value, time):
        # type: (str, str, float) -> None
        """
        设置Molang变量。

        参数：
            - name (str)：要设置的变量的名称。
            - value (str)：变量的值。
            - time (float)：变量的持续时间。

        返回：
            无返回值。
        """
        pass

    def setBoundTo(self, target):
        # type: (object) -> None
        """
        设置绑定目标。

        参数：
            - target (object)：要绑定到的目标对象。

        返回：
            无返回值。
        """
        pass

    def playAnimation(self, entityId, animation, repeat=False, duration=.0, freeze=None, speed=1.0, freezeTime=None, delay=0):
        # type: (int, str, bool, float, bool, float, float, int) -> None
        """
        播放动画。

        参数：
            - entityId (int)：要播放动画的实体的唯一标识符。
            - animation (str)：要播放的动画的名称。
            - repeat (bool)：是否循环播放动画，默认为False。
            - duration (float)：动画的持续时间（以秒为单位），默认为0。
            - freeze (bool)：是否在播放动画时冻结实体，默认为None。
            - speed (float)：动画的播放速度，默认为1.0。
            - freezeTime (float)：冻结时间（以秒为单位），默认为None。
            - delay (int)：延迟播放动画的时间（以毫秒为单位），默认为0。

        返回：
            无返回值。
        """
        pass

    def bindModel(self, boneName, modelName, rotation=[0, 0, 0], offset=[0, 0, 0]):
        # type: (str, str, list, list) -> None
        """
        将骨骼模型绑定到实体的特定骨骼上。

        参数：
            - boneName (str)：要绑定到的骨骼的名称。
            - modelName (str)：要绑定的模型的名称。
            - rotation (list)：模型相对于骨骼的旋转角度（欧拉角），默认为[0, 0, 0]。
            - offset (list)：模型相对于骨骼的偏移量，默认为[0, 0, 0]。

        返回：
            无返回值。
        """
        pass

    def getLocation(self, clearCache=False):
        # type: () -> Vector
        """
        获取实体的当前位置。

        参数：
            - clearCache (bool)：是否清除位置缓存，并重新获取最新位置，默认为False。

        返回：
            - location (Vector)：包含实体当前位置信息的向量对象。
        """
        pass

    def isSneaking(self):
        # type: () -> bool
        """
        判断玩家当前是否潜行状态。

        参数：
            - 无

        返回：
            - sneaking (bool)：玩家是否处于潜行状态，是则返回True，否则返回False
        """
        return False


    def setVariable(self, name, value, send=True):
        # type: (str, float, bool) -> None
        """
        设置变量的值。

        参数：
            - name (str)：变量名称
            - value (float)：变量的新值
            - send (bool)：是否发送更新通知，默认为True

        返回：
            - 无
        """
        pass

    def markNew(self, button, isNew=None, hide=None):
        # type: (str, bool, bool) -> None
        """
        将玩家菜单中的按钮标记为新，或隐藏。

        参数：
            - button (str)：按钮的路径
            - isNew (bool)：按钮的新状态，如果为None，则不改变新状态
            - hide (bool)：是否隐藏按钮，如果为None，则不隐藏按钮

        返回：
            - 无
        """
        pass

    def addVariable(self, name, value):
        # type: (str, float) -> None
        """
        增加变量的值。

        参数：
            - name (str)：变量名称
            - value (float)：增加的值

        返回：
            - 无
        """
        pass

    def addBattlePassCount(self, name, value):
        # type: (str, float) -> None
        """
        增加战令变量的值。

        参数：
            - name (str)：变量名称
            - value (float)：增加的值

        返回：
            - 无
        """
        pass

    def getVariable(self, name):
        # type: (str or VariableType) -> float
        """
        获取变量的值。
        传入的name若不包含#，则返回玩家的该变量的值
        若包含，则根据以下规则返回对应的值：
            item#物品名： 返回玩家有的该物品数量
            time#变量名： 返回距离“该变量值代表的时间”的秒数
            stat#属性名：返回该实体的当前该属性值
            buffstack#魔法名： 返回该实体拥有的此BUFF的层数，若没有该BUFF则返回0
            skill#技能名： 返回该玩家拥有的此技能等级
            mobcount#半径#怪物ID： 返回该玩家附近“半径”格内的该怪物数量
        参数：
            - name (str or VariableType)：变量名称或VariableType对象

        返回：
            - value (float)：变量的值
        """
        return 0.0


    def resetStatType(self, source):
        # type: (str) -> None
        """
        重置指定来源的属性。

        参数：
            - type (str)：属性类型

        返回：
            - 无
        """
        pass

    def addStat(self, source, stat, refresh=True):
        # type: (str, Stat, bool) -> None
        """
        增加属性。

        参数：
            - type (str)：属性来源
            - stat (Stat)：属性对象
            - refresh (bool)：是否刷新属性，默认为True

        返回：
            - 无
        """
        pass

    def removeHandlers(self, keyword):
        # type: (str) -> bool
        """
        根据指定关键词，移除相关的词条Handler。

        参数：
            - keyword (str)：关键词

        返回：
            - removed (bool)：是否成功移除处理程序
        """
        return False


    def refreshEquipment(self):
        # type: () -> None
        '''
        刷新角色的装备属性、特效、词条等状态。
        参数：
            无
        返回：
            无
        '''
        pass

    def resetSpeedBuff(self, name, thisAmount, force=False):
        # type: (str, bool) -> None
        """
        重置速度增益效果。

        参数：
            - name (str)：增益效果名称
            - thisAmount (float）：增益效果数值
            - force (bool)：是否强制重置，默认为False

        返回：
            - None
        """
        pass

    def getHandler(self, tagId):
        # type: (str) -> object
        """
        获取指定的词条Handler。

        参数：
            - tagId (str)：标签ID

        返回：
            - handler (object)：处理程序对象
        """
        pass

    def sendHoverMessage(self, message):
        # type: (str) -> None
        """
        发送悬停消息。消息会显示在玩家的屏幕中上方。重复的消息不会显示两遍

        参数：
            - message (str)：消息内容

        返回：
            - None
        """
        pass

    def removeParticle(self, entity=None, name=None, count=None):
        # type: (Fighter/Vector/str, str, int) -> None
        """
        移除此玩家看到的指定的粒子效果。

        参数：
            - entity (Fighter/Vector/str)：粒子所属实体（可选）
            - name (str)：粒子名称（可选）
            - count (int)：移除数量（可选）

        返回：
            - None
        """
        pass

    def playParticleWorld(self, name, location):
        # type: (str, Vector/tuple) -> None
        """
        让此玩家看到世界播放的粒子效果。

        参数：
            - name (str)：粒子名称
            - location (Vector/tuple)：位置坐标

        返回：
            - None
        """
        pass

    def playParticleEntity(self, name, offset, rotation, entityId):
        # type: (str, Vector/tuple, Vector/tuple, Fighter/int) -> None
        """
        让此玩家看到指定实体周围播放的粒子效果。

        参数：
            - name (str)：粒子名称
            - offset (Vector/tuple)：偏移量
            - rotation (Vector/tuple)：旋转角度
            - entityId (Fighter/int)：实体ID

        返回：
            - None
        """
        pass

    def GetItem(self, slot):
        # type: (int) -> LegendaryItem
        """
        获取指定槽位上的物品。

        参数：
            - slot (int)：槽位索引

        返回：
            - LegendaryItem or None：获取到的物品对象
        """
        pass

    def takeItem(self, itemType, amount):
        # type: (ItemType, int) -> int
        """
        拿走指定类型和数量的物品。

        参数：
            - itemType (ItemType)：物品类型
            - amount (int)：物品数量

        返回：
            - int：实际拿走的物品数量
        """
        pass

    def getItemHasAmount(self, itemType):
        # type: (ItemType) -> int
        """
        获取指定物品类型的物品数量。

        参数：
            - itemType (ItemType)：物品类型

        返回：
            - int：物品的数量
        """
        pass

    def checkInvLock(self):
        # type: () -> None
        """
        检查背包是否有交易锁。玩家可在设置中锁定背包，这样就无法消耗任何物品

        参数：
            - None

        返回：
            - bool：背包是否被锁定（True表示被锁定，False表示未被锁定）
        """
        pass

    def giveItem(self, item, isPickupItem=False, force=False, message=True):
        # type: (object, bool, bool, bool) -> bool or int
        """
        给予物品

        参数：
            - item (object)：要给予的物品
            - isPickupItem (bool)：是否为被拾取的物品，默认为False
            - force (bool)：是否强制给予物品，默认为False
            - message (bool)：是否发送消息提示，默认为True

        返回：
            - success (bool or int)：成功给予物品返回True，否则返回False或错误代码
        """
        return False


    def SetItem(self, slot, item):
        # type: (int, Legendaryitem) -> None
        """
        设置物品到指定槽位

        参数：
            - slot (int)：槽位编号
            - item (Legendaryitem)：要设置的物品
        """
        pass

    def getItemMaxStackSize(self, item):
        # type: (Legendaryitem) -> int
        """
        获取物品的最大堆叠数量

        参数：
            - item (Legendaryitem)：物品对象

        返回：
            - maxStackSize (int)：物品的最大堆叠数量
        """
        return 0


    def isSilenced(self, name):
        # type: (str) -> bool
        """
        判断是否被沉默

        参数：
            - name (str)：尝试释放的魔法名

        返回：
            - silenced (bool)：是否被沉默
        """
        return False


    def _equip(self, itemDict, slot):
        # type: (LegendaryItem or dict or tuple, int) -> bool
        """
        加载装备属性、模型、特效等

        参数：
            - itemDict (LegendaryItem or dict or tuple)：装备的物品
            - slot (int)：装备的槽位

        返回：
            - result (bool)：装备是否成功
        """
        pass

    def applyStats(self, item, slot):
        # type: (LegendaryItem, int) -> None
        """
        应用装备属性

        参数：
            - item (LegendaryItem)：装备的属性字典
            - slot (int)：装备的槽位

        返回：
            - bool：是否成功应用属性
        """
        pass

    def applyOutfit(self, item, renderSetting, equipType):
        # type: (LegendaryItem, EntityRenderSetting, int) -> None
        """
        应用装备外观

        参数：
            - item (LegendaryItem)：装备的属性字典
            - renderSetting (EntityRenderSetting): 实体的客户端显示信息
            - slot (int)：装备的槽位

        返回：
            - bool：是否成功应用属性
        """
        pass

    def getHealth(self):
        # type: () -> float
        """
        获取生命值。

        返回：
            - health (float)：生命值
        """
        return 0.0


    def clearType(self, type):
        # type: (str) -> None
        """
        清除指定来源的属性。

        参数：
            - type (str)：状态类型
        """
        pass

    def getStat(self, name, checkHandlers=True, includeTypes=None, source=None):
        # type: (str) -> Stat
        """
        获取指定属性。

        参数：
            - name (str)：属性名称
            - checkHandlers (bool)：是否检查处理程序，默认为 True
            - includeTypes (list)：包括的状态类型列表，默认为 None
            - source (object)：属性来源，默认为 None

        返回：
            - stat (Stat)：属性对象
        """
        pass

    def getStatAmount(self, name, default=.0, includeTypes=None, source=None, checkHandlers=True):
        # type: (str, float, list, str, bool) -> float
        """
        获取指定属性的数值。

        参数：
            - name (str)：属性名称
            - default (float)：默认值，默认为 0.0
            - includeTypes (list)：包括的状态类型列表，默认为 None
            - source (str)：属性来源，默认为 None
            - checkHandlers (bool)：是否检查词条，默认为 True

        返回：
            - amount (float)：属性数值
        """
        return 0.0


    def triggerHandlers(self, type, *args):
        # type: (str, tuple or data) -> None
        """
        触发词条Handler。

        参数：
            - type (str)：事件名
            - args (tuple or data)：事件信息
        """
        pass

    def setTargetingHealth(self, target):
        # type: (Fighter) -> None
        """
        设置当前的目标血条。

        参数：
            - target (Fighter)：目标实体

        返回：
            - None
        """
        pass

    def addCheat(self, count, source):
        # type: (int, str) -> None
        """
        添加作弊次数。

        参数：
            - count (int)：作弊次数
            - source (str)：作弊来源

        返回：
            - None
        """
        pass

    def _checkCheatKick(self, reason):
        # type: (str) -> None
        """
        检查是否需要踢出作弊玩家。

        参数：
            - reason (str)：踢出原因

        返回：
            - None
        """
        pass

    def kick(self, reason):
        # type: (str) -> None
        """
        踢出玩家。

        参数：
            - reason (str)：踢出原因

        返回：
            - None
        """
        pass

    def _updateCheat(self):
        # type: () -> None
        """
        更新作弊检测。
        返回：
            - None
        """
        pass

    def isInvincible(self):
        # type: () -> bool
        """
        判断玩家是否无敌。

        参数：
            - None

        返回：
            - isInvincible (bool)：是否无敌
        """
        return False


    def isAirborne(self):
        # type: () -> bool
        """
        判断玩家是否空中。

        参数：
            - None

        返回：
            - isAirborne (bool)：是否空中
        """
        return False


    def attack(self, victim, reason, baseDamage=.0, hurtEffect=True, override=False, allTargets=None, element=Element.NORMAL, graphic=False, bypassNegative=False, source=None, extraCrit=0, maxDamage=0, dealDamage=True):
        # type: (Fighter, str, float, bool, bool, set[Fighter], int, bool, bool, str, int, int, bool) -> Battle or None
        """
        用于进行攻击的方法。

        参数：
            - victim (Fighter)：攻击的目标。
            - reason (str)：攻击的原因。
            - baseDamage (float, optional)：基础伤害，默认为0.0。
            - hurtEffect (bool, optional)：是否有受伤特效，默认为True。
            - override (bool, optional)：是否覆盖之前的攻击，默认为False。
            - allTargets (set[Fighter], optional)：与目标相关联的所有战斗单位的集合，默认为None。
            - element (int, optional)：攻击元素类型，默认为Element.NORMAL。
            - graphic (bool, optional)：是否播放攻击动画，默认为False。
            - bypassNegative (bool, optional)：是否忽略负面效果，默认为False。
            - source (str, optional)：伤害来源，如"entity_attack". 默认为None。
            - extraCrit (int, optional)：额外暴击率，默认为0。
            - maxDamage (int, optional)：最大伤害值，默认为0。
            - dealDamage (bool, optional)：是否造成伤害，默认为True。

        返回：
            - battle (Battle or None)：战斗对象或空。如果攻击无效或者出现异常，则返回空。
        """
        pass

    def getLevel(self):
        # type: () -> int
        """
        获取当前等级。（非原版的经验等级）

        返回：
            - level (int)：当前战斗单位的等级。
        """
        return 0


    def entityPerformedAttack(self, entityId, targetId, color, targetLoc):
        # type: (Any, Any, int, Vector or tuple, optional) -> None
        """
        用于播放实体攻击动画的方法。

        参数：
            - entityId (Any)：实体的ID。
            - targetId (Any)：目标实体的ID。
            - color (int)：攻击元素的颜色。
            - targetLoc (Vector or tuple, optional)：目标实体的位置，默认为None。
        """
        pass

    def dealDamage(self, attacker, amount, reason, hurtEffect=True, crit=0, element=Element.NORMAL, fontSize=3, ignoreShield=False, source=None, popDamage=True):
        # type: (Fighter, float, str, bool, bool, Element, int, bool, str, bool) -> bool
        """
        对此实体造成伤害

        参数：
            - attacker (Fighter)：攻击者对象
            - amount (float)：伤害数值
            - reason (str)：伤害原因
            - hurtEffect (bool)：是否显示受伤特效，默认为 True
            - crit (bool)：暴击标志，0表示非暴击，1表示暴击1级，2表示暴击2级，3表示暴击3级，默认为0
            - element (Element)：伤害元素类型，默认为 Element.NORMAL
            - fontSize (int)：伤害数字的字体大小，默认为3
            - ignoreShield (bool)：是否忽略防御盾，默认为 False
            - source (None or str)：伤害来源，默认为 None
            - popDamage (bool)：是否显示伤害数值，默认为 True

        返回：
            - bool：是否成功处理伤害
        """
        pass

    def popDamageText(self, amount, attacker, element=None, crit=0, source="", fontSize=8, ignoreShield=False):
        # type: (float, Fighter, Element, int, str, int, bool) -> None
        """
        显示浮空伤害数值

        参数：
            - amount (float)：伤害数值
            - attacker (Fighter)：攻击者对象
            - element (Element)：伤害元素类型，默认为 None
            - crit (int)：暴击标志，0表示非暴击，1表示暴击1级，2表示暴击2级，3表示暴击3级，默认为0
            - source (str)：伤害来源，默认为空字符串
            - fontSize (int)：伤害数字的字体大小，默认为8
            - ignoreShield (bool)：是否忽略防御盾，默认为 False
        """
        pass

    def getUid(self):
        # type: () -> None
        """
        获取玩家UID。若不是玩家则返回None

        返回：
            - str：玩家唯一标识符
        """
        pass

    def resetCheatCheck(self):
        # type: () -> None
        """
        重置作弊检查。

        参数：
            - 无

        返回：
            - 无
        """
        pass

    def teleportTo(self, v, callEvent=True, skipCheck=False):
        # type: (Vector/tuple/list, bool, bool) -> None
        """
        传送到指定位置。

        参数：
            - v (Vector/tuple/list)：目标位置坐标或向量
            - callEvent (bool)：是否触发事件，默认为True
            - skipCheck (bool)：是否跳过位置检查，默认为False

        返回：
            - 无
        """
        pass

    def setFlying(self, flying):
        # type: (bool) -> None
        """
        设置飞行状态。

        参数：
            - flying (bool)：飞行状态

        返回：
            - 无
        """
        pass

    def setGliding(self, gliding):
        # type: (bool) -> None
        """
        设置滑翔状态。

        参数：
            - gliding (bool)：滑翔状态

        返回：
            - 无
        """
        pass

    def addBuff(self, activeBuff):
        # type: (ActiveBuff) -> None
        """
        将一个Buff加入已激活的Buff列表。

        参数：
            - activeBuff (ActiveBuff)：待添加的主动Buff。

        返回：
            - 无
        """
        pass

    def lookAt(self, vector, time, blockInput=True, firstPerson=False, switchToFirstPerson=False):
        # type: (Vector/tuple/list, int/float, bool, bool, bool) -> None
        """
        看向指定位置。

        参数：
            - vector (Vector/tuple/list)：目标位置坐标或向量。
            - time (int/float)：转向时间。
            - blockInput (bool)：是否阻塞输入，默认为True。
            - firstPerson (bool)：是否使用第一人称视角，默认为False。
            - switchToFirstPerson (bool)：是否切换至第一人称视角，默认为False。

        返回：
            - 无
        """
        pass

    def rotateTo(self, vector, firstPerson=False):
        # type: (tuple/list, bool) -> None
        """
        将实体旋转至指定方向。

        参数：
            - vector (tuple/list)：欧拉角度向量。
            - firstPerson (bool)：是否使用第一人称视角，默认为False。

        返回：
            - 无
        """
        pass

    def getEyeLocation(self):
        # type: () -> Vector
        """
        获取实体的眼睛（准星）位置。

        参数：
            - 无

        返回：
            - (Vector)：实体眼睛位置的向量。
        """
        return Vector()


    def getHeight(self):
        # type: () -> float
        """
        获取实体高度。

        参数：
            - 无

        返回：
            - (float)：实体的高度。
        """
        return 0.0


    def getRotation(self, param=None):
        # type: (dict) -> Vector
        """
        获取实体的旋转角度。

        参数：
            - param (dict)：附加参数。

        返回：
            - (Vector)：欧拉角度向量，表示实体的旋转角度。
        """
        return Vector()


    def getDirection(self, param=None):
        # type: (dict) -> Vector
        """
        获取实体的朝向向量。

        参数：
            - param (dict)：包含参数的字典，可选，默认为 None。

        返回：
            - direction (Vector)：朝向向量。
        """
        return Vector()


    def getBoundingBox(self):
        # type: () -> CuboidBoundingBox
        """
        获取实体的碰撞箱。注意此碰撞箱的基点处于实体当前的坐标

        返回：
            - bb (CuboidBoundingBox)：包围盒对象。
        """
        pass

    def heal(self, healer, amount, allTargets=None):
        # type: (Fighter, float, list) -> bool
        """
        治疗实体。

        参数：
            - healer (Fighter)：治疗者实体。
            - amount (float)：治疗量。
            - allTargets (list)：所有目标实体的列表，可选，默认为 None。

        返回：
            - success (bool)：治疗是否成功。
        """
        return False


    def healReal(self, attacker, amount, reason=None):
        # type: (Fighter, float) -> bool
        """
        实体受到真实治疗。

        参数：
            - attacker (Fighter)：攻击者实体。
            - amount (float)：治疗量。
            - reason (str)：治疗原因，可选，默认为 None。

        返回：
            - success (bool)：治疗是否成功。
        """
        pass

    def setOwner(self, owner):
        # type: (Fighter) -> None
        """
        设置实体的主人。一般用于召唤物

        参数：
            - owner (Fighter)：所有者实体。

        返回：
            无
        """
        pass

    def shakeCamera(self, strength, duration, delay=0):
        # type: (float, float, float) -> None
        """
        震动实体的相机。

        参数：
            - strength (float)：震动强度。
            - duration (float)：震动持续时间。
            - delay (float)：延迟时间，可选，默认为 0。

        返回：
            无
        """
        pass

    def isPlayerSide(self):
        # type: () -> bool
        """
        判断实体是否属于玩家一方。

        返回：
            - isPlayerSide (bool)：是否属于玩家一方。
        """
        pass

    def isAlly(self, target):
        # type: (Fighter) -> bool
        """
        判断实体是否是目标实体的盟友。一般用于判断是否可以伤害。

        参数：
            - target (Fighter)：目标实体。

        返回：
            - isAlly (bool)：是否是盟友。
        """
        return False


    def addShield(self, amount, duration=99999, key=None):
        # type: (float, int, None or str) -> None
        """
        添加护盾。

        参数：
            - amount (float)：护盾的数量。
            - duration (int)：护盾的持续时间，默认为99999。
            - key (None or str)：护盾的键值，默认为None。

        返回：
            - None
        """
        pass

    def getLastDamager(self):
        # type: () -> Fighter or None
        """
        获取最后攻击者。

        参数：
            - 无

        返回：
            - fighter (Fighter or None)：最后攻击者的对象或者None。
        """
        return Fighter()


    def silenceSpell(self, name, keywords):
        # type: (str, list or None) -> None
        """
        沉默魔法。魔法名包含关键字的会无法释放

        参数：
            - name (str)：法术名称。
            - keywords (list or None)：关键词列表，如果为None则表示取消沉默。

        返回：
            - None
        """
        pass

    def handleDeath(self, killerInfo=None):
        # type: (dict or None) -> None
        """
        处理角色死亡事件。

        参数：
            - killerInfo (dict or None)：击杀者的信息，默认为None。

        返回：
            - None
        """
        pass

    def spectate(self, fighter):
        # type: (Fighter) -> None
        """
        观战指定实体。观战时自动进入暂停状态

        参数：
            - fighter (Fighter)：要观战的角色对象。

        返回：
            - None
        """
        pass

    def isPlayerFighter(self):
        # type: () -> None
        """
        判断是否为玩家角色。某个玩家的人机镜像也会返回True，尽管其isPlayer属性是False

        参数：
            - 无

        返回：
            - bool：True表示是玩家角色，False表示不是玩家角色。
        """
        pass

    def reduceShield(self, attacker, amount, source):
        # type: (object, float, str) -> float
        """
        减少护盾值。

        参数：
            - attacker (object)：攻击者对象
            - amount (float)：减少的护盾值
            - source (str)：护盾值减少的来源

        返回：
            - amount (float)：剩余的护盾值
        """
        return 0.0


    def getChannelTargetLoc(self, range):
        # type: (float) -> object
        """
        获取通道目标位置。

        参数：
            - range (float)：距离范围

        返回：
            - loc (object)：目标位置对象
        """
        pass

    def sendDamageText(self, attacker, text, gravity=0.1, font=3, reason=None):
        # type: (object, str, float, int, str) -> None
        """
        发送伤害浮空字。

        参数：
            - attacker (object)：攻击者对象
            - text (str)：伤害文本
            - gravity (float)：重力加速度，默认为0.1
            - font (int)：字体，默认为3
            - reason (str)：伤害原因

        返回：
            无
        """
        pass

    def syncShield(self):
        # type: () -> None
        """
        同步护盾值。

        参数：
            无

        返回：
            无
        """
        pass

    def getDot(self):
        # type: () -> float
        """
        获取DOT（持续伤害）值。

        参数：
            无

        返回：
            - dot (float)：DOT值
        """
        return 0.0


    def syncDot(self):
        # type: () -> None
        """
        同步DOT（持续伤害）值。

        参数：
            无

        返回：
            无
        """
        pass

    def reduceMinimumShield(self, amount):
        # type: (float) -> float
        """
        减少最小的护盾值。

        参数：
            - amount (float)：减少的护盾值

        返回：
            - amount (float)：剩余的护盾值
        """
        return 0.0


    def getShield(self, shieldName=None):
        # type: (str) -> float
        """
        获取护盾值。

        参数：
            - shieldName (str)：护盾名称，默认为None

        返回：
            - shield (float)：护盾值
        """
        return 0.0


    def setHealth(self, health, checkDeath=True):
        # type: (float, bool) -> None
        """
        设置生命值。

        参数：
            - health (float)：生命值
            - checkDeath (bool)：是否检查死亡，默认为True

        返回：
            无
        """
        pass

    def setMana(self, mana):
        # type: (float) -> None
        """
        设置当前魔力。

        参数：
            - mana (float)：魔法值

        返回：
            无
        """
        pass

    def getMana(self):
        # type: () -> float
        """
        获取当前魔力。

        参数：
            无

        返回：
            - mana (float)：魔法值
        """
        return 0.0


    def getMaxMana(self):
        # type: () -> float
        """
        获取最大魔法值。

        参数：
            无

        返回：
            - maxMana (float)：最大魔法值
        """
        return 0.0


    def setMaxHealth(self, health):
        # type: (float) -> None
        """
        设置最大生命值。

        参数：
            - health (float)：最大生命值

        返回：
            无
        """
        pass

    def isDead(self):
        # type: () -> bool
        """
        判断是否死亡。

        参数：
            无

        返回：
            - dead (bool)：是否死亡
        """
        return False


    def loadBuffs(self):
        # type: () -> None
        """
        加载Buff。见saveBuffs

        参数：
            无

        返回：
            无
        """
        pass

    def clearBuffs(self):
        # type: () -> None
        """
        清除Buff。

        参数：
            无
        返回：
            无
        """
        pass

    def saveBuffs(self):
        # type: () -> None
        """
        保存Buff。身上的可保存的Buff会被保存到存档中，并清除掉。随时可以用loadBuffs()重新加载

        参数：
            无

        返回：
            无
        """
        pass

    def AddEffect(self, effectName, duration, amplifier, showParticles):
        # type: (str, int, int, bool) -> None
        """
        添加药水效果。

        参数：
            - effectName (str)：效果名称
            - duration (int)：持续时间
            - amplifier (int)：增幅器
            - showParticles (bool)：是否显示粒子效果

        返回：
            无
        """
        pass

    def GetEffects(self):
        # type: () -> list[dict[str, str or int]]
        """
        effectName    str    状态效果名称
        duration    int    状态效果剩余持续时间，单位秒
        amplifier    int    状态效果额外等级
        """
        pass

    def addTween(self, tween):
        # type: (Tween) -> None
        """
        添加一个Tween对象到该对象的动画列表中

        参数：
            - tween (Tween)：要添加的Tween对象

        返回：
            无返回值
        """
        pass

    def setPrefixAndSuffix(self, prefix=None, suffix=None):
        # type: (str, str) -> None
        """
        设置前缀和后缀文本

        参数：
            - prefix (str)：前缀文本，默认为None
            - suffix (str)：后缀文本，默认为None

        返回：
            无返回值
        """
        pass

    def removeTempEquipment(self):
        # type: () -> None
        """
        移除临时装备并触发相应事件

        参数：
            无参数

        返回：
            无返回值
        """
        pass

    def inBattle(self, message=None):
        # type: (str) -> None
        """
        判断是否在战斗状态，并发送提示信息

        参数：
            - message (str)：提示信息，默认为None

        返回：
            - bool：是否在战斗状态
        """
        pass

    def setAvoidBattle(self, avoidBattle, teleportBack=True):
        # type: (bool, bool) -> None
        """
        设置是否避免战斗

        参数：
            - avoidBattle (bool)：是否避免战斗
            - teleportBack (bool)：是否回传，默认为True

        返回：
            无返回值
        """
        pass

    def setGameMode(self, gameModeId):
        # type: (int) -> None
        """
        设置游戏模式

        参数：
            - gameModeId (int)：游戏模式ID

        返回：
            无返回值
        """
        pass

    def updateUltCharge(self, charge):
        # type: (float) -> None
        """
        更新终极技能的充能值

        参数：
            - charge (float)：充能值

        返回：
            无返回值
        """
        pass

    def reduceCooldown(self, spellName, cooldownReduced):
        # type: (str/Spell, float) -> None
        """
        减少冷却时间

        参数：
            - spellName (str/Spell)：技能名称或技能对象
            - cooldownReduced (float)：减少的冷却时间

        返回：
            无返回值
        """
        pass

    def sendTitle(self, title, subtitle):
        # type: (str, str) -> None
        """
        发送自定义标题信息

        参数：
            - title (str)：标题文本
            - subtitle (str)：副标题文本

        返回：
            无返回值
        """
        pass

    def sendVanillaTitle(self, title, subtitle):
        # type: (str, str) -> None
        """
        发送原版标题信息

        参数：
            - title (str)：标题文本
            - subtitle (str)：副标题文本

        返回：
            无返回值
        """
        pass

    def sendHeader(self, title, subtitle, percent=0.5, update=False, duration=5.0):
        # type: (str, str, float, bool, float) -> None
        """
        发送自定义头部信息

        参数：
            - title (str)：标题文本
            - subtitle (str)：副标题文本
            - percent (float)：进度百分比，默认为0.5
            - update (bool)：是否更新进度条，默认为False
            - duration (float)：显示时间，默认为5.0秒

        返回：
            无返回值
        """
        pass

    def setBoundingBox(self, size):
        # type: (tuple) -> None
        """
        设置碰撞体积大小

        参数：
            - size (tuple)：碰撞体积大小的元组

        返回：
            无返回值
        """
        pass

    def markChangedEquipment(self):
        # type: () -> None
        """
        标记已更改装备，稍后会自动调用refreshEquipments()并刷新装备

        参数：
            - 无

        返回：
            - 无
        """
        pass

    def playMusic(self, sound, distance=16, volume=1.0, pitch=1.0, location=None):
        # type: (str, int, float, float, tuple) -> None
        """
        播放音乐

        参数：
            - sound (str)：音乐名称
            - distance (int)：音乐传播距离，默认为16
            - volume (float)：音量大小，默认为1.0
            - pitch (float)：音调，默认为1.0
            - location (tuple)：音乐播放位置，默认为None

        返回：
            - 无
        """
        pass

    def playCustomSound(self, sound, distance=16, volume=1.0, pitch=1.0, location=None):
        # type: (str, int, float, float, tuple) -> None
        """
        播放自定义声音

        参数：
            - sound (str)：声音名称
            - distance (int)：声音传播距离，默认为16
            - volume (float)：音量大小，默认为1.0
            - pitch (float)：音调，默认为1.0
            - location (tuple)：声音播放位置，默认为None

        返回：
            - 无
        """
        pass

    def vibrate(self, duration):
        # type: (float) -> None
        """
        震动

        参数：
            - duration (float)：震动持续时间

        返回：
            - 无
        """
        pass

    def playSoundByStr(self, sound, distance=15, volume=1.0, pitch=1.0, minVol=.0, location=None):
        # type: (str, int, float, float, float, tuple) -> None
        """
        根据声音字符串播放声音

        参数：
            - sound (str)：声音字符串，就是附加包中的sounds_definitions.json里定义的声音
            - distance (int)：声音传播距离，默认为15
            - volume (float)：音量大小，默认为1.0
            - pitch (float)：音调，默认为1.0
            - minVol (float)：最小音量，默认为0.0
            - location (tuple)：声音播放位置，默认为None

        返回：
            - 无
        """
        pass

    def playSound(self, sound, block=None, entity=None):
        # type: (SysSoundType, str, str) -> None
        """
        播放声音（已废弃）

        参数：
            - sound (SysSoundType)：系统声音名称
            - block (str)：方块类型，默认为None
            - entity (str)：实体类型，默认为None

        返回：
            - 无
        """
        pass

    def sendMessage(self, message):
        # type: (str or dict) -> None
        """
        发送聊天栏消息

        参数：
            - message (str or dict)：消息内容，可以是字符串或字典

        返回：
            - 无
        """
        pass

    def dropBoundItem(self, item):
        # type: (Item) -> None
        """
        丢弃物品在实体位置，且只有此实体能捡起来

        参数：
            - item (Item)：要丢弃的物品

        返回：
            - 无
        """
        pass

    def teleportToPlayer(self, playerName):
        # type: (str) -> None
        """
        传送到指定玩家

        参数：
            - playerName (str)：玩家名称

        返回：
            - 无
        """
        pass

    def getIdentifier(self):
        # type: () -> str
        """
        获取标识符

        参数：
            - 无

        返回：
            - id (str)：实体标识符
        """
        return ""


    def getMaxHealth(self):
        # type: () -> int
        """
        获取最大生命值

        参数：
            - 无

        返回：
            - maxHealth (int)：最大生命值
        """
        return 0


    def resetCannotBattle(self, callLater=False):
        # type: (bool) -> None
        """
        重置无法战斗状态

        参数：
            - callLater (bool)：是否延迟调用，默认为False

        返回：
            - 无
        """
        pass

    def setVelocity(self, direction):
        # type: (Vector) -> None
        """
        设置速度

        参数：
            - direction (Vector)：速度方向

        返回：
            - 无
        """
        pass

    def getVelocity(self):
        # type: () -> Vector
        """
        获取速度

        参数：
            - 无

        返回：
            - velocity (Vector)：速度向量
        """
        pass

    def respawn(self, spawnLoc=None):
        # type: (Vector) -> None
        """
        复活，仅玩家有效
        复活点规则，优先级从高到低：
        1. 传入的spawnLoc
        2. 用/setspawn %p 设置了的复活点
        3. 名为 respawn 的warp点
        4. 名为 spawn 的warp点

        参数：
            - spawnLoc (Vector)：重生位置，默认为None。

        返回：
            - 无
        """
        pass

    def getEquipmentForOutfit(self, slot, equipType):
        # type: (str, int) -> Item
        """
        获取用于加载外观的装备物品

        参数：
            - slot (str)：槽位名称
            - equipType (int)：装备类型

        返回：
            - equipment (Item)：物品实例或None
        """
        return Item()


    def getEquipment(self, slot, equipType):
        # type: (str, int) -> Item
        """
        获取用于加载属性的装备物品

        参数：
            - slot (str)：槽位名称
            - equipType (int)：装备类型

        返回：
            - equipment (Item)：物品实例或None
        """
        return Item()


    def getDimension(self):
        # type: () -> int
        """
        获取当前维度 0=主世界 1=下界 2=末地 大于等于20：自定义维度

        参数：
            - 无

        返回：
            - dimension (int)：维度编号
        """
        return 0


class ConsoleSender:
    def __init__(self):
        # type: () -> None
        """
        从系统执行指令时，fighter是这个类的实例。仅用于接受信息并将它打印在后台
        """
        pass

class MasterSender:
    def __init__(self):
        """
        从调试控制台执行指令时，fighter是这个类的实例。仅用于接受信息并将它传回给Master
        """
        pass

